using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using Newtonsoft.Json;
using System.Linq;
using Newtonsoft.Json.Linq;
using System;

// 用于解析决策对象的类
[System.Serializable]
public class Wu_GeneralDecision
{
    [JsonProperty("哪个将军(who)")]
    public string 将军名称;

    [JsonProperty("带领多少士兵(how many)")]
    public string 士兵数量;

    [JsonProperty("从哪里出发(where)")]
    public string 出发地点;

    [JsonProperty("去到哪个地方(where)")]
    public string 目的地;

    [JsonProperty("行为")]
    public string 行为;

    [JsonProperty("阵型")]
    public string 阵型;
}

public class Wu_General_Controller : MonoBehaviour
{
    // 单例模式
    public static Wu_General_Controller Instance { get; private set; }

    // 引用对话管理器
    [SerializeField] private Wu_DeepSeekDialogueManager deepSeekManager;

    // 引用将军组件
    [SerializeField] private GanNing ganNing;
    [SerializeField] private LuXun luXun;
    [SerializeField] private SunCe sunCe;
    [SerializeField] private SunShangXiang sunShangXiang;
    // 最后应用的决策回合
    private int lastAppliedDecisionTurn = 0;

    void Awake()
    {
        // 实现单例模式
        if (Instance == null)
        {
            Instance = this;
            DontDestroyOnLoad(gameObject);
        }
        else if (Instance != this)
        {
            Destroy(gameObject);
        }
    }

    void Start()
    {
        // 自动查找组件
        if (deepSeekManager == null) deepSeekManager = FindObjectOfType<Wu_DeepSeekDialogueManager>();
        if (ganNing == null) ganNing = FindObjectOfType<GanNing>();
        if (luXun == null) luXun = FindObjectOfType<LuXun>();
        if (sunCe == null) sunCe = FindObjectOfType<SunCe>();
        if (sunShangXiang == null) sunShangXiang = FindObjectOfType<SunShangXiang>();
        // 启动协程定期检查决策栈
        StartCoroutine(CheckDecisionsRoutine());
    }

    // 定期检查决策栈，应用新的决策
    private IEnumerator CheckDecisionsRoutine()
    {
        while (true)
        {
            // 每秒检查一次
            yield return new WaitForSeconds(1f);

            // 检查是否有新决策
            CheckAndApplyDecisions();
        }
    }

    // 检查决策栈，如果有新决策则应用
    public void CheckAndApplyDecisions()
    {
        if (deepSeekManager == null || deepSeekManager.jsonStack.Count == 0)
        {
            return; // 无决策可应用
        }

        // 获取当前回合数
        int currentTurn = deepSeekManager.npcCharacter.GetCurrentTurn();

        // 如果当前回合的决策已经应用过，则跳过
        if (currentTurn <= lastAppliedDecisionTurn)
        {
            return;
        }

        Debug.Log($"【将军控制】应用第{currentTurn}回合的决策");

        // 将Stack转为数组以便访问最新决策（栈顶）
        var stackArray = deepSeekManager.jsonStack.ToArray();

        // 获取最新决策对象
        var latestDecision = stackArray[0];

        // 尝试应用决策到各个将军
        try
        {
            // 将决策对象转换为JSON字符串
            string decisionJson = JsonConvert.SerializeObject(latestDecision);
            Debug.Log($"【将军控制】获取到的JSON格式: {decisionJson.Substring(0, Mathf.Min(100, decisionJson.Length))}...");

            // 创建存储决策的列表
            List<Wu_GeneralDecision> decisionsList = new List<Wu_GeneralDecision>();

            try
            {
                // 首先尝试解析为数组格式
                Wu_GeneralDecision[] decisionItems = JsonConvert.DeserializeObject<Wu_GeneralDecision[]>(decisionJson);
                if (decisionItems != null && decisionItems.Length > 0)
                {
                    decisionsList.AddRange(decisionItems);
                    Debug.Log($"【将军控制】成功解析为决策数组，包含 {decisionItems.Length} 个决策");
                }
            }
            catch (JsonException)
            {
                Debug.Log("【将军控制】JSON不是数组格式，尝试解析为单个对象...");
                try
                {
                    // 尝试解析为单个对象格式
                    Wu_GeneralDecision singleDecision = JsonConvert.DeserializeObject<Wu_GeneralDecision>(decisionJson);
                    if (singleDecision != null && !string.IsNullOrEmpty(singleDecision.将军名称))
                    {
                        decisionsList.Add(singleDecision);
                        Debug.Log($"【将军控制】成功解析为单个决策对象: {singleDecision.将军名称}");
                    }
                }
                catch (JsonException ex)
                {
                    Debug.Log($"【将军控制】无法解析为单个对象: {ex.Message}，尝试使用JToken分析...");

                    // 使用JToken进行更灵活的解析
                    JToken token = JToken.Parse(decisionJson);

                    // 检查是否有嵌套的决策数组
                    foreach (var prop in token.Children())
                    {
                        if (prop is JProperty property)
                        {
                            if (property.Value is JArray array)
                            {
                                Debug.Log($"【将军控制】发现潜在的决策数组属性: {property.Name}");
                                try
                                {
                                    string arrayJson = array.ToString();
                                    Wu_GeneralDecision[] nestedDecisions = JsonConvert.DeserializeObject<Wu_GeneralDecision[]>(arrayJson);
                                    if (nestedDecisions != null && nestedDecisions.Length > 0)
                                    {
                                        decisionsList.AddRange(nestedDecisions);
                                        Debug.Log($"【将军控制】从嵌套数组成功解析出 {nestedDecisions.Length} 个决策");
                                    }
                                }
                                catch (Exception nestEx)
                                {
                                    Debug.LogWarning($"【将军控制】解析嵌套数组失败: {nestEx.Message}");
                                }
                            }
                            else if (property.Value is JObject obj &&
                                    (obj["将军名称"] != null || obj["哪个将军(who)"] != null))
                            {
                                Debug.Log($"【将军控制】发现嵌套的单个决策对象: {property.Name}");
                                try
                                {
                                    string objJson = obj.ToString();
                                    Wu_GeneralDecision nestedDecision = JsonConvert.DeserializeObject<Wu_GeneralDecision>(objJson);
                                    if (nestedDecision != null && !string.IsNullOrEmpty(nestedDecision.将军名称))
                                    {
                                        decisionsList.Add(nestedDecision);
                                        Debug.Log($"【将军控制】从嵌套对象成功解析出决策: {nestedDecision.将军名称}");
                                    }
                                }
                                catch (Exception nestEx)
                                {
                                    Debug.LogWarning($"【将军控制】解析嵌套对象失败: {nestEx.Message}");
                                }
                            }
                        }
                    }
                }
            }

            // 应用解析出的所有决策
            if (decisionsList.Count > 0)
            {
                // 过滤掉孙坚的决策（因为Wu_ZhuGong脚本已删除）
                var Wu_GeneralDecisions = decisionsList.Where(d => d.将军名称 != "孙坚").ToList();

                // 应用每个将军的决策
                foreach (var decision in Wu_GeneralDecisions)
                {
                    ApplyDecisionToGeneral(decision);
                }

                // 更新最后应用的决策回合
                lastAppliedDecisionTurn = currentTurn;
                Debug.Log($"【将军控制】成功应用第{currentTurn}回合的决策，共{Wu_GeneralDecisions.Count}个（已忽略孙坚的决策）");
            }
            else
            {
                Debug.LogWarning("【将军控制】未能从决策对象中提取出任何有效决策");
            }
        }
        catch (System.Exception e)
        {
            Debug.LogError($"【将军控制】应用决策时出错: {e.Message}");
        }
    }

    // 应用单个决策到对应的将军（供侦察兵调用）
    public void ApplySingleDecision(Wu_GeneralDecision decision)
    {
        // 忽略孙坚的决策（因为Wu_ZhuGong脚本已删除）
        if (decision.将军名称 == "孙坚")
        {
            Debug.Log($"【将军控制】收到对孙坚的命令，但孙坚组件不可用，命令被忽略");
            return;
        }

        Debug.Log($"【将军控制】收到侦察兵传递的单个决策，应用给{decision.将军名称}");
        ApplyDecisionToGeneral(decision);
    }

    // 应用单个决策到对应的将军
    public void ApplyDecisionToGeneral(Wu_GeneralDecision decision)
    {
        // 根据将军名称找到对应的将军组件
        switch (decision.将军名称)
        {
            case "甘宁":
                if (ganNing != null)
                {
                    // 使用通用的更新方法处理关羽的决策
                    UpdateGeneral(ganNing, decision);
                }
                break;

            case "陆逊":
                if (luXun != null)
                {
                    UpdateGeneral(luXun, decision);
                }
                break;

            case "孙策":
                if (sunCe != null)
                {
                    UpdateGeneral(sunCe, decision);
                }
                break;

            case "孙尚香":
                if (sunShangXiang != null)
                {
                    UpdateGeneral(sunShangXiang, decision);
                }
                break;

            default:
                Debug.LogWarning($"【将军控制】未知将军名称: {decision.将军名称}");
                break;
        }
    }

    // 更新将军属性（这里假设所有将军都继承自同一类型）
    private void UpdateGeneral(MonoBehaviour general, Wu_GeneralDecision decision)
    {
        // 解析士兵数量字符串
        string[] soldierCounts = decision.士兵数量.Split(',');
        int infantryCount = 0;
        int archerCount = 0;
        int cavalryCount = 0;

        // 尝试解析步兵、弓箭手和骑兵数量
        if (soldierCounts.Length >= 1) int.TryParse(soldierCounts[0].Trim(), out infantryCount);
        if (soldierCounts.Length >= 2) int.TryParse(soldierCounts[1].Trim(), out archerCount);
        if (soldierCounts.Length >= 3) int.TryParse(soldierCounts[2].Trim(), out cavalryCount);

        Debug.Log($"【将军控制】解析士兵数量：步兵={infantryCount}, 弓箭手={archerCount}, 骑兵={cavalryCount}");

        // 这里我们需要根据具体的将军类型进行处理
        if (general is GanNing ganNing)
        {
            // 更新甘宁的属性
            ganNing.targetPosition = decision.目的地;
            ganNing.formation = decision.阵型;
            ganNing.is_attacking = decision.行为 == "进攻";
            ganNing.is_arrive = false; // 重置到达状态
            ganNing.activity = decision.行为; // 设置activity为当前行为

            // 设置士兵数量
            ganNing.infantryAccount = infantryCount;
            ganNing.archerAccount = archerCount;
            ganNing.cavalryAccount = cavalryCount;

            Debug.Log($"【将军控制】已更新甘宁的目标位置为 {decision.目的地}，阵型为 {decision.阵型}，行为为 {decision.行为}，士兵配置为 {decision.士兵数量}");
        }
        else if (general is LuXun luXun)
        {
            // 更新陆逊的属性
            luXun.targetPosition = decision.目的地;
            luXun.formation = decision.阵型;
            luXun.is_attacking = decision.行为 == "进攻";
            luXun.is_arrive = false; // 重置到达状态
            luXun.activity = decision.行为; // 设置activity为当前行为

            // 设置士兵数量
            luXun.infantryAccount = infantryCount;
            luXun.archerAccount = archerCount;
            luXun.cavalryAccount = cavalryCount;

            Debug.Log($"【将军控制】已更新陆逊的目标位置为 {decision.目的地}，阵型为 {decision.阵型}，行为为 {decision.行为}，士兵配置为 {decision.士兵数量}");
        }
        else if (general is SunCe sunCe)
        {
            // 更新孙策的属性
            sunCe.targetPosition = decision.目的地;
            sunCe.formation = decision.阵型;
            sunCe.is_attacking = decision.行为 == "进攻";
            sunCe.is_arrive = false; // 重置到达状态
            sunCe.activity = decision.行为; // 设置activity为当前行为

            // 设置士兵数量
            sunCe.infantryAccount = infantryCount;
            sunCe.archerAccount = archerCount;
            sunCe.cavalryAccount = cavalryCount;

            Debug.Log($"【将军控制】已更新孙策的目标位置为 {decision.目的地}，阵型为 {decision.阵型}，行为为 {decision.行为}，士兵配置为 {decision.士兵数量}");
        }
        else if (general is SunShangXiang sunShangXiang)
        {
            // 更新孙尚香的属性
            sunShangXiang.targetPosition = decision.目的地;
            sunShangXiang.formation = decision.阵型;
            sunShangXiang.is_attacking = decision.行为 == "进攻";
            sunShangXiang.is_arrive = false; // 重置到达状态
            sunShangXiang.activity = decision.行为; // 设置activity为当前行为
        }
    }

    // 手动触发决策检查（可从外部调用）
    public void ForceApplyDecisions()
    {
        CheckAndApplyDecisions();
    }
}